{"componentChunkName":"component---src-templates-post-jsx","path":"/[JPA]5/","result":{"data":{"site":{"siteMetadata":{"title":"SUbbb"}},"markdownRemark":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 엔티티들은 대부분 다른 엔티티와 연관관계가 있다. 그런데 객체는 참조(주소)를 사용하고, 테이블은 외래 키를 사용해 관계를 맺는다. 이 둘은 완전히 다른 특징을 가지므로, 객체 관계 매핑에서 가장 어려운 부분이라고 할 수 있다. \n이 장에서는 객체의 참조와 테이블의 외…","html":"<p><em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em></p>\n<blockquote>\n<p>엔티티들은 대부분 다른 엔티티와 <strong>연관관계</strong>가 있다. 그런데 객체는 참조(주소)를 사용하고, 테이블은 외래 키를 사용해 관계를 맺는다. 이 둘은 완전히 다른 특징을 가지므로, 객체 관계 매핑에서 가장 어려운 부분이라고 할 수 있다. <br/>\n이 장에서는 <strong>객체의 참조와 테이블의 외래 키를 매핑하는 것</strong>을 목표로 한다.</p>\n<ul>\n<li>\n<p><strong>방향</strong></p>\n<ul>\n<li>단방향, 양방향이 있다. 객체관계에만 방향이 존재하고, 테이블에서는 항상 양방향이다.</li>\n</ul>\n</li>\n<li>\n<p><strong>다중성</strong></p>\n<ul>\n<li>N:1, 1:N, 1:1, N:M 다중성이 있다.</li>\n</ul>\n</li>\n<li>\n<p><strong>연관관계의 주인</strong></p>\n<ul>\n<li>객체를 양방향 연관관계로 만들면 연관관계의 주인을 정해야 한다.</li>\n</ul>\n</li>\n</ul>\n</blockquote>\n<h2>💫 단방향 연관관계</h2>\n<p>연관관계 중에선 다대일(N:1) 단방향 관계를 가장 먼저 이해해야 한다. </p>\n<ul>\n<li>회원과 팀이 있다.</li>\n<li>회원은 하나의 팀에만 소속될 수 있다.</li>\n<li>회원과 팀은 <strong>다대일 관계</strong>이다.</li>\n</ul>\n<p><strong>객체 연관관계</strong><br/></p>\n<ul>\n<li>회원 객체는 <code class=\"language-text\">Member.team</code> 필드 (멤버변수)로 팀 객체와 연관관계를 맺는다.</li>\n<li>회원 객체와 팀 객체는 <strong>단방향 관계</strong>다. 회원은 팀을 알 수 있지만, 반대로 팀은 회원을 알 수 없다. (팀에서 접근하는 필드가 없기 때문)</li>\n</ul>\n<p><strong>테이블 연관관계</strong><br/></p>\n<ul>\n<li>회원 테이블은 <code class=\"language-text\">TEAM_ID</code> 외래 키로 팀 테이블과 연관관계를 맺는다.</li>\n<li>회원 테이블과 팀 테이블은 <strong>양방향 관계</strong>다. 조인을 통해 서로서로에 접근할 수 있다. </li>\n</ul>\n<p>외래 키 하나로 어떻게 양방향 조인이 가능할까?</p>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">SELECT * FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID\n\nSELECT * FROM TEAM T JOIN MEMBER M ON T.TEAM_ID = M.TEAM_ID</code>\n        </deckgo-highlight-code>\n<p><strong>객체 연관관계와 테이블 연관관계의 가장 큰 차이</strong><br/>\n참조를 통한 연관관계는 항상 <strong>단방향</strong>이다. 객체 간 연관관계를 양방향으로 만들고 싶으면 반대쪽에도 필드를 추가해 참조를 보관해야 한다. (즉 연관관계를 하나 더 생성) 이는 정확하게는 <strong>양방향 관계가 아닌 서로 다른 단방향 관계 2개</strong>가 되는 셈이다.</p>\n<p>반면에 테이블은 <strong>외래 키 하나로 양방향 조인이 가능</strong>하다.</p>\n<p><strong>객체 연관관계 vs. 테이블 연관관계 정리</strong><br/></p>\n<ul>\n<li>\n<p>객체는 참조(주소)로 연관관계를 맺는다.</p>\n<ul>\n<li>단방향 연관관계다.</li>\n<li>양방향이 되기 위해서는 단방향 연관관계를 1개 더 만들어야 한다.</li>\n</ul>\n</li>\n<li>\n<p>테이블은 외래 키로 연관관계를 맺는다.</p>\n<ul>\n<li>양방향 연관관계다.</li>\n</ul>\n</li>\n</ul>\n<p>연관된 데이터를 조회할 때 객체는 <code class=\"language-text\">a.getB().getC()</code> 를 사용하지만 테이블은 조인을 사용한다.</p>\n<h3>➰ 순수한 객체 연관관계</h3>\n<p>순수하게 객체만 사용한 연관관계 코드이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class Member {\n  private String id;\n  private String username;\n\n  private Team team; // 팀 참조 보관\n\n  public void setTeam(Team team) {\n    this.team = team;\n  }\n\n  ...\n\n\n}\n\npublic class Team {\n  private String id;\n  private String name;\n\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<p>아래 코드로 회원1과 2를 팀1에 소속시킨다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public static void main(String[] args) {\n  Member member1 = new Member(&quot;member1&quot;, &quot;회원1&quot;);\n  Member member2 = new Member(&quot;member2&quot;, &quot;회원2&quot;);\n  Team team1 = new Team(&quot;team1&quot;, &quot;팀1&quot;);\n\n  member1.setTeam(team1);\n  member2.setTeam(team1);\n\n  Team findTeam = member1.getTeam();\n}</code>\n        </deckgo-highlight-code>\n<p>이처럼 객체는 참조를 사용해 연관관계를 탐색할 수 있는데, 이를 <strong>객체 그래프 탐색</strong>이라 한다.</p>\n<h3>➰ 테이블 연관관계</h3>\n<p>데이터베이스 테이블의 회원과 팀의 관계를 살펴본다. 두 테이블은 모두 <code class=\"language-text\">TEAM_ID</code> 를 가지고, 회원 테이블의 <code class=\"language-text\">TEAM_ID</code> 에 외래 키 제약조건을 설정했다.</p>\n<ul>\n<li>INSERT SQL로 회원1과 2를 팀1에 소속시킨다.</li>\n<li>\n<p>SELECT SQL로 회원1이 소속된 팀을 조회한다.</p>\n<ul>\n<li>이때 <code class=\"language-text\">TEAM_ID</code> 에 대한 <code class=\"language-text\">JOIN</code> 을 사용한다.</li>\n</ul>\n</li>\n</ul>\n<p>이처럼 데이터베이스는 외래 키를 사용해 연관관계를 탐색할 수 있는데, 이를 <strong>조인</strong>이라 한다.</p>\n<h3>➰ 객체 관계 매핑</h3>\n<p>지금까지 다룬 객체, 테이블 연관관계를 JPA를 사용한 매핑으로 바꿔본다.</p>\n<ul>\n<li>객체 연관관계: 회원 객체의 <code class=\"language-text\">Member.team</code> 필드 사용</li>\n<li>테이블 연관관계: 회원 테이블의 <code class=\"language-text\">MEMBER.TEAM_ID</code> 외래 키 컬럼 사용</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Member {\n  @Id\n  @Column(name = &quot;MEMBER_ID&quot;)\n  private String id;\n\n  private String username;\n\n  @ManyToOne\n  @JoinColumn(name = &quot;TEAM_ID&quot;)\n  private Team team;\n\n  public void setTeam(Team team) {\n    this.team = team;\n  }\n\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Team {\n  @Id\n  @Column(name = &quot;TEAM_ID&quot;)\n  private String id;\n\n  private String name;\n\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Member.team</code> 과 <code class=\"language-text\">MEMBER.TEAM_ID</code> 를 매핑하는 것이 연관관계 매핑이다. 이를 위해 사용한 annotation을 분석한다.</li>\n<li>\n<p><code class=\"language-text\">@ManyToOne</code></p>\n<ul>\n<li>이름 그대로 다대일 관계라는 매핑 정보를 의미한다. 연관관계 매핑 시에는 이렇게 다중성을 나타내는 annotation을 필수로 사용해야 한다.</li>\n</ul>\n</li>\n<li>\n<p><code class=\"language-text\">JoinColumn(name = \"TEAM_ID\")</code></p>\n<ul>\n<li>외래 키를 매핑할 때 사용한다. <code class=\"language-text\">name</code> 속성으로 매핑할 외래 키 이름을 지정한다. 생략가능한 annotation이다.</li>\n<li>이를 생략하면, 외래 키를 찾을 때 기본 전략을 사용한다.</li>\n<li>\n<blockquote>\n<p><strong>기본 전략</strong> : 필드명 + _ + 참조하는 테이블의 컬럼명</p>\n<ul>\n<li>ex. 필드명(team) + _ + 참조하는 테이블의 컬럼명(TEAM<em>ID) = team</em>TEAM_ID 외래 키</li>\n</ul>\n</blockquote>\n</li>\n</ul>\n</li>\n</ul>\n<hr>\n<h2>💫 연관관계 사용</h2>\n<p>연관관계를 등록, 수정, 삭제, 조회하는 예제를 통해 알아본다.</p>\n<h3>➰ 저장</h3>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public void testSave() {\n  Team team1 = new Team(&quot;team1&quot;, &quot;팀1&quot;);\n  em.persist(team1);\n\n  Member member1 = new Member(&quot;member1&quot;, &quot;회원1&quot;);\n  member1.setTeam(team1);\n  em.persist(member1);\n\n  Member member2 = new Member(&quot;member2&quot;, &quot;회원2&quot;);\n  member2.setTeam(team1);\n  em.persist(member2);\n}</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p>JPA에서 엔티티 저장할 때 연관된 모든 엔티티는 영속 상태여야 한다.</p>\n</blockquote>\n<p>회원 엔티티는 팀 엔티티를 참조(<code class=\"language-text\">setTeam</code>)하고 저장(<code class=\"language-text\">persist</code>)했다. JPA는 참조한 팀의 식별자(<code class=\"language-text\">Team.id</code>)를 외래 키로 사용해 적절한 <strong>등록 쿼리를 생성</strong>할 것이다.</p>\n<h3>➰ 조회</h3>\n<p>연관관계가 있는 엔티티를 조회하는 방법은 2가지이다.</p>\n<ul>\n<li>객체 그래프 탐색(객체 연관관계를 사용한 조회)</li>\n<li>객체지향 쿼리 사용(JPQL)</li>\n</ul>\n<p><strong>객체 그래프 탐색</strong><br/>\n<code class=\"language-text\">member.getTeam()</code> 을 사용해 회원과 연관된 팀 엔티티를 조회할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member member = em.find(Member.class, &quot;member1&quot;);\nTeam team = member.getTeam();</code>\n        </deckgo-highlight-code>\n<p><strong>객체지향 쿼리 사용</strong><br/>\n예를 들어 회원을 대상으로 조회하는데 팀1에 소속된 회원만 조회하려면 회원과 연관된 팀 엔티티를 검색 조건으로 사용해야 한다. SQL은 연관된 테이블을 조인해서 검색조건을 사용하면 된다. JPQL도 조인을 지원한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">private static void queryLogicJoin(EntityManager em) {\n  String jpql = &quot;select m from Member m join m.team t where &quot; + &quot;t.name=:teamName&quot;;\n\n  List&lt;Member&gt; resultList = em.createQuery(jpql, Member.class)\n      .setParameter(&quot;teamName&quot;, &quot;팀1&quot;)\n      .getResultList();\n\n  for (Member member : resultList) {\n    System.out.println(&quot;[query] member.username=&quot; + member.getUsername());\n  }\n}</code>\n        </deckgo-highlight-code>\n<p>회원이 팀과 관계를 가지고 있는 필드(<code class=\"language-text\">m.team</code>)을 통해 회원과 팀 엔티티를 조인했다. 그리고 <code class=\"language-text\">where</code> 절에서 조인한 <code class=\"language-text\">t.name</code> 을 검색조건으로 사용해 원하는 회원만 검색했다.</p>\n<blockquote>\n<p><code class=\"language-text\">:teamName</code> 과 같이 :로 시작하는 것은 파라미터를 바인딩받는 문법이다.</p>\n</blockquote>\n<h3>➰ 수정</h3>\n<p>팀1 소속이던 회원을 새로운 팀2에 소속하도록 수정한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">private static void updateRelation(Entitymanager em) {\n  Team team2 = new Team(&quot;team2&quot;, &quot;팀2&quot;);\n  em.persist(team2);\n\n  Member member = em.find(Member.class, &quot;member1&quot;);\n  member.setTeam(team2);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPA는 UPDATE SQL을 생성해 자동으로 처리한다.</li>\n</ul>\n<h3>➰ 연관관계 제거</h3>\n<p>회원1을 팀에 소속하지 않도록 변경한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">private static void deleteRelation(Entitymanager em) {\n  Member member = em.find(Member.class, &quot;member1&quot;);\n  member.setTeam(null);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>연관관계를 <code class=\"language-text\">null</code> 로 설정했다. 이때는 다음과 같은 SQL이 생성된다.</li>\n</ul>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">UPDATE MEMBER SET TEAM_ID=null, ... WHERE ID=&#39;member1&#39;</code>\n        </deckgo-highlight-code>\n<h3>➰ 연관된 엔티티 삭제</h3>\n<p>삭제를 위해서는 기존 연관관계를 먼저 제거하고 삭제해야 한다.</p>\n<ul>\n<li>그렇지 않으면 <strong>외래 키 제약조건</strong>으로 인해 데이터베이스에서 오류가 발생한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member1.setTeam(null);\nmember2.setTeam(null);\nem.remove(team);</code>\n        </deckgo-highlight-code>\n<hr>\n<h2>💫 양방향 연관관계</h2>\n<p>이제 회원에서 팀으로 접근하고 반대 방향인 팀에서도 회원으로 접근할 수 있도록 양방향 연관관계로 매핑해본다.</p>\n<ul>\n<li>\n<p>회원과 팀은 다대일 관계다. 반대로 팀에서 회원은 일대다 관계다.</p>\n<ul>\n<li>일대다 관계는 여러 건과 연관관계를 맺을 수 있어 컬렉션을 사용해야 한다. <code class=\"language-text\">Team.members</code> 를 <code class=\"language-text\">List</code> 컬렉션으로 추가했다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p>회원 → 팀 (<code class=\"language-text\">Member.team</code>) <br/>\n팀 → 회원 (<code class=\"language-text\">Team.members</code>)</p>\n</blockquote>\n<p>데이터베이스의 테이블은 <strong>외래 키 하나로 양방향으로 조회</strong>할 수 있다. 따라서 데이터베이스에서는 추가할 내용이 전혀 없다.</p>\n<h3>➰ 양방향 연관관계 매핑</h3>\n<p>회원 엔티티에서는 변경할 부분이 없다. 팀 엔티티를 보자.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">@Entity\npublic class Team {\n  @Id\n  @Column(name = &quot;TEAM_ID&quot;)\n  private String id;\n\n  private String name;\n\n  @OneToMany(mappedBy = &quot;team&quot;)\n  private List&lt;Member&gt; members = new ArrayList();\n\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>팀과 회원은 일대다 관계다. 따라서 팀 엔티티에 컬렉션인 <code class=\"language-text\">List&lt;Member> members</code> 를 추가했다.</li>\n<li>또한 일대다 관계 매핑을 위한 annotation을 사용했다. </li>\n<li><code class=\"language-text\">mappedBy</code> 속성은 양방향 매핑일 때 반대쪽 매핑의 필드 이름을 값으로 지정한다. (반대쪽 매핑이 <code class=\"language-text\">Member.team</code>)</li>\n</ul>\n<h3>➰ 일대다 컬렉션 조회</h3>\n<p>팀에서 회원 컬렉션으로 객체 그래프 탐색을 사용해 특정 팀에 소속된 회원들을 조회할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public void biDirection() {\n  Team team = em.find(Team.class, &quot;team1&quot;);\n  List&lt;Member&gt; members = team.getMembers();\n\n  for (Member member : members) {\n    System.out.println(&quot;member.username = &quot; + member.getUsername());\n  }\n}</code>\n        </deckgo-highlight-code>\n<hr>\n<h2>💫 연관관계의 주인</h2>\n<p><code class=\"language-text\">@OneToMany</code> annotation 사용 시 <code class=\"language-text\">mappedBy</code> 는 왜 필요할까? </p>\n<ul>\n<li>\n<p>객체에는 양방향 연관관계라는 것이 없다. 서로 다른 단방향 연관관계가 2개일 뿐이다. </p>\n<ul>\n<li>반면, 데이터베이스는 외래 키 하나로 양쪽이 서로 조인하기에 양방향 연관관계를 맺을 수 있다.</li>\n</ul>\n</li>\n<li>\n<p>엔티티를 단방향으로 매핑하면 참조를 하나만 사용해 이 참조로 외래 키를 관리하면 된다.</p>\n<ul>\n<li>하지만 양방향으로 매핑하면 \"회원 → 팀\" , \"팀 → 회원\" 으로 두 곳에서 서로를 참조한다. </li>\n<li>즉, <strong>객체의 연관관계를 관리하는 포인트가 2곳으로 늘어나게 되고,</strong> 참조는 둘인데 외래 키는 하나여서 차이가 발생한다.</li>\n<li>이때 JPA에서는 두 객체 연관관계 중 하나를 정해 테이블의 외래 키를 관리해야 하는데 이때 정해진 하나가 <strong>연관관계의 주인</strong>이 된다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 양방향 매핑의 규칙: 연관관계의 주인</h3>\n<p><strong>연관관계의 주인만이 데이터베이스 연관관계와 매핑되고, 외래 키를 관리(등록, 수정, 삭제)할 수 있다. 반면에 주인이 아닌 쪽은 읽기만 가능하다.</strong></p>\n<ul>\n<li>주인은 <code class=\"language-text\">mappedBy</code> 속성을 사용하지 않는다.</li>\n<li>주인이 아니면 <code class=\"language-text\">mappedBy</code> 속성을 사용해 속성의 값으로 연관관계의 주인을 지정한다.</li>\n</ul>\n<p>연관관계의 주인을 어떻게 정해야 할까? 이는 곧 <strong>외래 키 관리자를 선택하는 것</strong>이다.</p>\n<ul>\n<li>\n<p>회원과 팀의 예에서는 회원 테이블에 있는 <code class=\"language-text\">TEAM_ID</code> 외래 키를 관리할 관리자를 선택하는 것이다. </p>\n<ul>\n<li>만약 회원 엔티티에 있는 <code class=\"language-text\">Member.team</code> 을 주인으로 선택하면 자기 테이블에 있는 외래 키를 관리하면 된다. </li>\n<li>하지만 팀 엔티티에 있는 <code class=\"language-text\">Team.members</code> 를 주인으로 선택하면 물리적으로 전혀 다른 테이블의 외래 키를 관리해야 한다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 연관관계의 주인은 외래 키가 있는 곳</h3>\n<p>\"연관관계의 주인은 테이블에 외래 키가 있는 곳으로 정해야 한다.\" 위의 예에서는 <code class=\"language-text\">Member.team</code> 이 주인이 된다. </p>\n<ul>\n<li>주인이 아닌 <code class=\"language-text\">Team.members</code> 에는 <code class=\"language-text\">mappedBy=\"team\"</code> 속성을 사용해 주인이 아님을 설정하고. 속성 값으로는 연관관계의 주인(<code class=\"language-text\">team</code>)을 명시한다.</li>\n</ul>\n<p>이로서 연관관계의 주인만 데이터베이스 연관관계와 매핑되고 외래 키를 관리할 수 있다. 주인이 아닌 반대편은 읽기만 가능하고 외래 키를 변경하지는 못한다.</p>\n<blockquote>\n<p>데이터베이스 테이블의 다대일, 일대다 관계에서는 항상 다 쪽이 외래 키를 가진다. 따라서 <code class=\"language-text\">@ManyToOne</code> 에는 <code class=\"language-text\">mappedBy</code> 속성이 없다.</p>\n</blockquote>\n<hr>\n<h2>💫 양방향 연관관계 저장</h2>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public void testSave() {\n  Team team1 = new Team(&quot;team1&quot;, &quot;팀1&quot;);\n  em.persist(team1);\n\n  Member member1 = new Member(&quot;member1&quot;, &quot;회원1&quot;);\n  member1.setTeam(team1);\n  em.persist(member1);\n\n  Member member2 = new Member(&quot;member2&quot;, &quot;회원2&quot;);\n  member2.setTeam(team1);\n  em.persist(member2);\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>회원에 연관관계의 주인인 <code class=\"language-text\">Member.team</code> 필드를 이용해 회원과 팀의 연관관계를 설정하고 저장했다. 이는 <strong>단방향 연관관계에서 사렾본 회원과 팀을 저장하는 코드와 동일</strong>하다.</li>\n<li>연관관계의 주인이 아닌 방향은 값을 설정하지 않아도 데이터베이스에 외래 키 값이 정상 입력되고, 설령 입력한다고 해도 이는 <strong>무시</strong>되어 영향을 주지 않는다.</li>\n</ul>\n<hr>\n<h2>💫 양방향 연관관계의 주의점</h2>\n<p>가장 흔히 하는 실수는 <strong>연관관계의 주인에는 값을 입력하지 않고, 주인이 아닌 곳에만 값을 입력</strong>하는 것이다. 이는 방금 언급했듯 무시되어 영향을 주지 않는 동작이기에 데이터베이스에 외래 키 값이 정상적으로 저장되지 않으면 이부터 확인해야 한다.</p>\n<blockquote>\n<p><strong>\"연관관계의 주인만이 외래 키의 값을 변경할 수 있다.\"</strong></p>\n</blockquote>\n<h3>➰ 순수한 객체까지 고려한 양방향 연관관계</h3>\n<p>그렇다면 연관관계의 주인에만 값을 저장하고 주인이 아닌 곳에는 값을 저장하지 않아도 될까?</p>\n<ul>\n<li>사실 <strong>객체 관점에서는 양쪽 방향에 모두 값을 입력해주는 것이 가장 안전하다.</strong> </li>\n<li>양쪽 방향 모두 값을 입력하지 않으면 JPA를 사용하지 않는 순수한 객체 상태에서 심각한 문제가 발생할 수 있다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// ex.JPA를 사용하지 않고 엔티티에 대한 테스트 코드를 작성하는 경우\npublic void test순수한객체_양방향() {\n  Team team1 = new Team(&quot;team1&quot;, &quot;팀1&quot;);\n  Member member1 = new Member(&quot;member1&quot;, &quot;회원1&quot;);\n  Member member2 = new Member(&quot;member2&quot;, &quot;회원2&quot;);\n  member1.setTeam(team1);\n  member2.setTeam(team1);\n  \n  List&lt;Member&gt; members = team1.getMembers();\n  System.out.println(&quot;members.size = &quot; + members.size());\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPA를 사용하지 않는 순수한 객체다. <code class=\"language-text\">Member.team</code> 에만 연관관계를 설정했기에 <strong>팀에 소속된 회원이 하나도 없다.</strong></li>\n<li>\n<p>양방향은 양쪽 모두 관계를 설정해야 한다. 즉 반대방향으로도 설정이 이뤄져야 한다.</p>\n<ul>\n<li>이로서 순수한 객체 상태에서도 동작하며, 테이블의 외래 키도 정상 입력된다. (외래 키 값은 연관관계의 주인인 <code class=\"language-text\">Member.team</code> 값을 사용한다.)</li>\n</ul>\n</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member1.setTeam(team1); // 주인, 외래 키 관리\nteam1.getMembers().add(member1); // 주인 X, 저장 시 사용되지 않음</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p>결론 : 객체의 양방향 연관관계는 양쪽 모두 관계를 맺어주자.</p>\n</blockquote>\n<h3>➰ 연관관계 편의 메소드</h3>\n<p>양방향 연관관계는 결국 양쪽 모두 신경 써야 한다. 실수로 두 설정 메소드 중 하나만 호출해 양방향이 깨지는 경우가 발생할 수도 있다.</p>\n<ul>\n<li>따라서 두 코드를 하나인 것처럼 사용하는 것이 안전하다. <code class=\"language-text\">Member</code> 클래스의 <code class=\"language-text\">setTeam()</code> 메소드를 리팩토링한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class Member {\n  private Team team;\n\n  public void setTeam(Team team) {\n    this.team = team;\n    team.getMembers().add(this);\n  }\n  ...\n\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">setTeam</code> 메소드에서 양방향 관계를 모두 설정하도록 수정했다. 이렇게 한 번에 양방향 관계를 설정하는 메소드를 <strong>연관관계 편의 메소드</strong>라 한다.</li>\n</ul>\n<h3>➰ 연관관계 편의 메소드 작성 시 주의사항</h3>\n<p>사실 위와 같은 편의 메소드에는 버그가 있다. <strong><code class=\"language-text\">setTeam()</code> 을 호출한 직후에도 이전의 관계가 제거되지 않는 것</strong>이다.</p>\n<ul>\n<li>연관관계 변경 시에는 기존 팀이 있으면 그 관계를 삭제하고 새로운 관계를 맺는 코드로 바꿔야 한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public void setTeam(Team team) {\n  if (this.team != null) this.team.getMembers().remove(this);\n  this.team = team;\n  team.getMembers().add(this);\n} </code>\n        </deckgo-highlight-code>\n<hr>\n<h2>💫 정리</h2>\n<p>단방향 매핑과 비교해서 양방향 매핑은 복잡하다.</p>\n<ul>\n<li>연관관계의 주인 지정</li>\n<li>두 개의 단방향 연관관계를 양방향으로 만들기 위해 로직 관리</li>\n</ul>\n<blockquote>\n<p>연관관계가 하나인 <strong>단방향 매핑</strong> → 언제나 연관관계의 주인 <br/>\n<strong>양방향 매핑</strong> → 단방향 + 주인이 아닌 연관관계를 하나 추가 <br/>\n양방향의 장점은 <strong>반대방향으로 객체 그래프 탐색 기능이 추가</strong>된 것뿐!</p>\n</blockquote>\n<h2>📕 출처</h2>\n<p><strong>자바 ORM 표준 JPA 프로그래밍</strong> - 김영한</p>","frontmatter":{"title":"📚 5. 연관관계 매핑 기초","date":"March 13, 2022","update":"March 13, 2022","tags":["Java","JPA","SpringBoot"],"series":"📚 ORM 표준 JPA"},"fields":{"slug":"/[JPA]5/","readingTime":{"minutes":21.95}}},"seriesList":{"edges":[{"node":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","fields":{"slug":"/[JPA]1/"},"frontmatter":{"title":"📚 1. JPA 소개"}}},{"node":{"id":"f86fa867-f096-52ce-854a-ef00e49ebcdb","fields":{"slug":"/[JPA]2/"},"frontmatter":{"title":"📚 2. JPA 시작"}}},{"node":{"id":"ffb8392d-d300-51c1-8e71-a8943ef4b58d","fields":{"slug":"/[JPA]3/"},"frontmatter":{"title":"📚 3. 영속성 관리"}}},{"node":{"id":"f45d0c27-c0da-5191-8c86-2aef34b75f27","fields":{"slug":"/[JPA]4/"},"frontmatter":{"title":"📚 4. 엔티티 매핑"}}},{"node":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","fields":{"slug":"/[JPA]5/"},"frontmatter":{"title":"📚 5. 연관관계 매핑 기초"}}},{"node":{"id":"24c890e9-eebe-56bf-9db2-8660dcb3b783","fields":{"slug":"/[JPA]6/"},"frontmatter":{"title":"📚 6. 다양한 연관관계 매핑"}}},{"node":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","fields":{"slug":"/[JPA]7/"},"frontmatter":{"title":"📚 7. 고급 매핑"}}},{"node":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","fields":{"slug":"/[JPA]8/"},"frontmatter":{"title":"📚 8. 프록시와 연관관계 관리"}}},{"node":{"id":"5003d7a8-381f-550d-aecd-28caba14aba9","fields":{"slug":"/[JPA]9/"},"frontmatter":{"title":"📚 9. 값 타입"}}},{"node":{"id":"a41dc548-d976-533a-a680-96e86a627d35","fields":{"slug":"/[JPA]10/"},"frontmatter":{"title":"📚 10. 객체지향 쿼리 언어"}}},{"node":{"id":"4ef1a134-ac1d-5e69-9f85-7c1b5d7a8244","fields":{"slug":"/[JPA]11/"},"frontmatter":{"title":"📚 11. 웹 애플리케이션 제작"}}},{"node":{"id":"1a74ae89-3758-5cb9-938c-b8238d176c8c","fields":{"slug":"/[JPA]12/"},"frontmatter":{"title":"📚 12. 스프링 데이터 JPA"}}},{"node":{"id":"5900f638-1417-5a4a-a147-a228540a920b","fields":{"slug":"/[JPA]13/"},"frontmatter":{"title":"📚 13. 웹 애플리케이션과 영속성 관리"}}},{"node":{"id":"5f07d9ea-eadc-54ea-90b2-efe93297170f","fields":{"slug":"/[JPA]14/"},"frontmatter":{"title":"📚 14. 컬렉션과 부가 기능"}}},{"node":{"id":"838bd515-9bd3-5d4b-8f49-723d3f55688c","fields":{"slug":"/[JPA]15/"},"frontmatter":{"title":"📚 15. 고급 주제와 성능 최적화"}}},{"node":{"id":"1f449b33-36ba-58f9-915f-be058ee6ba3e","fields":{"slug":"/[JPA]16/"},"frontmatter":{"title":"📚 16. 트랜잭션과 락, 2차 캐시"}}}]},"previous":{"fields":{"slug":"/[JPA]4/"},"frontmatter":{"title":"📚 4. 엔티티 매핑"}},"next":{"fields":{"slug":"/[BOJ]14503/"},"frontmatter":{"title":"👩‍💻 14503. 로봇 청소기"}}},"pageContext":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","series":"📚 ORM 표준 JPA","previousPostId":"f45d0c27-c0da-5191-8c86-2aef34b75f27","nextPostId":"f1c04e8a-df0a-5294-949f-5f3a483cbcb0"}},"staticQueryHashes":[]}